package com.example.service;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.example.dao.Permission;
import com.example.dao.Role;
import com.example.dao.RolePermission;
import com.example.dao.mapper.PermissionMapper;
import com.example.dao.mapper.RolePermissionMapper;
import com.example.security.decision.UrlPermissionData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 功能描述
 * 权限目录service
 * @author: jimmy
 * @date: 2023年12月22日 12:39
 */
@Service
public class PermissionService {
    /**
     * 权限mapper
     */
    @Autowired
    private PermissionMapper permissionMapper;
    /**
     * 角色权限mapper
     */
    @Autowired
    private RolePermissionMapper rolePermissionMapper;
    /**
     * url匹配字符串与角色的关联数据
     */
    @Autowired
    private UrlPermissionData urlPermissionData;


    /**
     * 根据角色查询权限，此方法在用户登录后获取左侧目录
     * @param role
     * @return
     */
    public List<Permission> findPermissionsByRole(Role role) {
        return permissionMapper.findPermissionsByRole(role);
    }

    /**
     * 询所有权限
     * @return
     */
    public List<Permission> findAllPermissions() {
        return permissionMapper.findAllPermissions();
    }

    /**
     * 删除权限
     * @param id
     * @return
     */
    @Transactional
    public int deletePermissionById(Long id) {
        Map<String, Object> delMap = new HashMap<>();
        delMap.put("permission_id", id);
        //根据父目录删除其子目录下的权限分配
        int result = rolePermissionMapper.deleteRolePermissionByFirstId(id);
        //根据权限id删除权限分配
        result += rolePermissionMapper.deleteByMap(delMap);
        //根据权限id删除权限
        result += permissionMapper.deleteById(id);
        //根据权限父id删除权限
        result += permissionMapper.deleteByParentId(id);
        return result;
    }


    /**
     * 检查权限名称是否已经存在
     * @param permissionname
     * @param id
     * @return
     */
    public boolean isPermissionnameExisted(String permissionname, Long id) {
        Map<String, Object> param = new HashMap<>();
        param.put("permissionname", permissionname);
        param.put("id", id);
        return permissionMapper.findCountByPermissionname(param) > 0;
    }

    /**
     * 添加权限
     * @param permission
     * @return
     */
    public int insertPermission(Permission permission) {
        return permissionMapper.insert(permission);
    }

    /**
     * 更新目录
     * @param permission
     * @return
     */
    public int updatePermission(Permission permission) {
        return permissionMapper.updateById(permission);
    }

    /**
     * 根据角色id查询所有权限，及分配给角色的该权限的operation
     * @param roleId
     * @return
     */
    public List<Permission> findAllPermissionsByRoleId(Long roleId) {
        return permissionMapper.findAllPermissionsByRoleId(roleId);
    }

    /**
     * 根据角色id查询分配给该角色的权限id
     * @param roleId
     * @return
     */
    public List<Long> findPermissionIdsByRoleId(Long roleId) {
        return permissionMapper.findPermissionIdsByRoleId(roleId);
    }

    /**
     * 设置角色目录
     *
     * @param allData
     * @return
     */
    @Transactional
    public int attachPermissionToRole(List<RolePermission> allData) {
        int result = 0;
        for (RolePermission rp : allData) {
            //新增
            if (rp.getDatabaseOperation() == 0) {
                result += rolePermissionMapper.insert(rp);
            } else if (rp.getDatabaseOperation() == 1) {
                //修改
                UpdateWrapper<RolePermission> updateWrapper = new UpdateWrapper<>();
                updateWrapper.eq("role_id", rp.getRoleId()).eq("permission_id", rp.getPermissionId());
                result += rolePermissionMapper.update(rp, updateWrapper);
            } else {
                //删除
                result += rolePermissionMapper.deleteRolePermissionByBothId(rp);
            }
        }
        if(result>0){
            //更新静态数据，每一个资源所需要的角色
            urlPermissionData.loadResourceDefine();
        }
        return result;
    }

//    public List<String> findPermissionPatchStringByRole(Role role) {
//        return permissionMapper.findPermissionPatchStringByRole(role);
//    }

    /**
     * 根据目录id查询角色，检查目录是否被角色设置了
     * @param id
     * @return
     */
    public int findRoleCountByPermissionId(Long id) {
        return rolePermissionMapper.findRoleCountByPermissionId(id);
    }

    /**
     * 查询所有角色及其对应的匹配字符串
     * @return
     */
    public List<RolePermission> findAllRolePermission(){
        return rolePermissionMapper.findAllRolePermission();
    }

}
